package com.wc.fortnight_blue_bridge.Q16模拟二.J_旋转;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

/**
 * @Author congge
 * @Date 2024/11/23 23:19
 * @description
 * https://dasai.lanqiao.cn/pages/v7/dasai/prelim/prelim_examing.html?examUsperPaperId=338843&applyId=579285787961
 */
public class Main {
    /**
     * 【问题描述】
     * 小蓝正在玩一个寻宝游戏。寻宝游戏在一个方格图上进行。方格图中的每一个格子都有一个坐标 (r, c)，其中越往北 r 越小，越往南 r 越大，越往东 c 越大，越往西 c 越小。南北相邻方格的 c 坐标相同，r 坐标差一。东西相邻方格的 r 坐标相同， c 坐标差一。
     * 游戏开始时，小蓝站在 (0, 0) 处，面向北边。游戏区域无限大，且没有障碍。每一步，小蓝控制自己的角色走一步，他可以有如下三种选择：
     *
     * 向前走：朝现在的方向前进到相邻的方格中，并保持当前的方向。
     * 向左走：向左转90度，并前进到相邻的方格中（即进入到原来左边的方格），面向的方向变为了原来的左边。
     * 向右走：向右转90度，并前进到相邻的方格中（即进入到原来右边的方格），面向的方向变为了原来的右边。
     * 小蓝玩了一会儿，一共走了 n 步，他记录了自己的每一个动作。但是他没有找到宝藏。他怀疑前面的某一步出现了失误。他想知道，如果他改变之前的某一步，能到的位置有哪些。由于这个太复杂，他想知道最终到的位置（第 n 步后到的位置）有多少种。
     *
     * 【输入格式】
     * 输入的第一行包含一个整数 n ，表示小蓝走了 n 步。
     * 第二行包含一个长度为 n 的由大写字母组成的字符串，依次表示小蓝走的每一步。字母 F 、 L 、 R 分别表示对应的步是向前走、向左走、向右走。
     *
     * 【输出格式】
     * 输出一行，包含一个整数，表示如果改变某一步，可以到的位置的种类数。
     *
     * 【样例输入】
     * 3
     * FLR
     * 【样例输出】
     * 6
     * 【样例说明】
     * 如果不改变，三步依次走到：(-1, 0), (-1, -1), (-2, -1) ，最终位置为 (-2, -1) 。
     * 如果第一步改成 L，三步依次走到：(0, -1), (1, -1), (1, -2) ，最终位置为 (1, -2) 。
     * 如果第一步改成 R，三步依次走到：(0, 1), (-1, 1), (-1, 2) ，最终位置为 (-1, 2) 。
     * 如果第二步改成 F，三步依次走到：(-1, 0), (-2, 0), (-2, 1) ，最终位置为 (-2, 1) 。
     * 如果第二步改成 R，三步依次走到：(-1, 0), (-1, 1), (0, 1) ，最终位置为 (0, 1) 。
     * 如果第三步改成 F，三步依次走到：(-1, 0), (-1, -1), (-1, -2) ，最终位置为 (-1, -2) 。
     * 如果第三步改成 L，三步依次走到：(-1, 0), (-1, -1), (0, -1) ，最终位置为 (0, -1) 。
     *
     * 共有 6 种不同的最终位置。
     *
     * 【样例输入】
     * 4
     * RRRR
     * 【样例输出】
     * 6
     * 【样例说明】
     * 有 8 种改变方法：
     * 改为 FRRR ，最终位置为 (0, 0)；
     * 改为 LRRR ，最终位置为 (0, 0)；
     * 改为 RFRR ，最终位置为 (1, 1)；
     * 改为 RLRR ，最终位置为 (0, 2)；
     * 改为 RRFR ，最终位置为 (2, 0)；
     * 改为 RRLR ，最终位置为 (2, 2)；
     * 改为 RRRF ，最终位置为 (1, -1)；
     * 改为 RRRL ，最终位置为 (2, 0)。
     * 不同的最终位置共有 6 种。
     *
     * 【评测用例规模与约定】
     * 对于 30% 的评测用例，1 <= n <= 20。
     * 对于 60% 的评测用例，1 <= n <= 1000。
     * 对于所有评测用例，1 <= n <= 100000。
     */
    static FastReader sc = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);
    static int N = 100010;
    static char[] cs = new char[N];
    static int[][] point = new int[N][2];
    static int[] dx = new int[]{-1, 0, 1, 0}, dy = new int[]{0, 1, 0, -1};
    static Set<Integer> set = new HashSet<>();
    static int n;

    public static void main(String[] args) {
        n = sc.nextInt();
        cs = (" " + sc.next()).toCharArray();
        int x = 0, y = 0, op = 0;

        for (int i = 1; i <= n; i++) {
            if (cs[i] == 'L') op = (op - 1 + 4) % 4;
            if (cs[i] == 'R') op = (op + 1) % 4;
            x += dx[op];
            y += dy[op];
            point[i][0] = x;
            point[i][1] = y;
        }
        for (int i = 1; i <= n; i++) {
            int nx = point[n][0] - point[i - 1][0], ny = point[n][1] - point[i - 1][1];
            x = point[i - 1][0];
            y = point[i - 1][1];
            if (cs[i] == 'F') {
                work(-1, nx, ny, x, y);
                work(1, nx, ny, x, y);
            } else {
                work(0, nx, ny, x, y);
                if (cs[i] == 'L') work(1, nx, ny, x, y);
                else work(-1, nx, ny, x, y);
            }
        }
        out.println(set.size());
        out.flush();
    }

    static void work(int u, int x, int y, int ox, int oy){
        int dx = 0, dy = 0;
        // 旋转180
        if (u == 0) {
            dx = -x;
            dy = -y;
        }
        // 旋转-90
        if (u == -1) {
            dx = -y;
            dy = x;
        }
        // 旋转90
        if (u == 1) {
            dx = y;
            dy = -x;
        }
        int nx = ox + dx, ny = oy + dy;
        set.add(nx * N + ny);
    }
}

class FastReader {
    StringTokenizer st;
    BufferedReader br;

    FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    String nextLine() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return s;
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    // 是否由下一个
    boolean hasNext() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                String line = br.readLine();
                if (line == null)
                    return false;
                st = new StringTokenizer(line);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return true;
    }
}

